home *** CD-ROM | disk | FTP | other *** search
/ Mac Format 1994 October / Macformat17.cdr / Shareware City / Developers / shutdown-fx-20-c / sfx control app ƒ / Shell ƒ / main.c < prev    next >
C/C++ Source or Header  |  1994-07-11  |  12KB  |  360 lines
  1. /**********************************************************************\
  2.  
  3. File:        main.c
  4.  
  5. Purpose:    This module handles the event loop and event dispatching.
  6.  
  7. This program is free software; you can redistribute it and/or modify
  8. it under the terms of the GNU General Public License as published by
  9. the Free Software Foundation; either version 2 of the License, or
  10. (at your option) any later version.
  11.  
  12. This program is distributed in the hope that it will be useful,
  13. but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. GNU General Public License for more details.
  16.  
  17. You should have received a copy of the GNU General Public License
  18. along with this program in a file named "GNU General Public License".
  19. If not, write to the Free Software Foundation, 675 Mass Ave,
  20. Cambridge, MA 02139, USA.
  21.  
  22. \**********************************************************************/
  23.  
  24. #include "graphics.h"
  25. #include "main.h"
  26. #include "apple events.h"
  27. #include "integrity.h"
  28. #include "about.h"
  29. #include "help.h"
  30. #include "menus.h"
  31. #include "prefs.h"
  32. #include "environment.h"
  33. #include "progress.h"
  34. #include "error.h"
  35. #include "sfx.h"
  36. #include "program globals.h"
  37.  
  38. static    EventRecord            gCurrentEvent;
  39.  
  40. void main(void)
  41. {
  42.     Boolean            programIntegrityVerified;
  43.     Boolean            programIntegritySet;
  44.     
  45.     /* do integrity check before anything else; see integrity.c for details */
  46.     programIntegrityVerified=DoIntegrityCheck(&programIntegritySet);
  47.     
  48.     /* standard program initialization stuff */
  49.     MaxApplZone();    
  50.     InitGraf(&thePort);
  51.     InitFonts();
  52.     FlushEvents(everyEvent, 0);
  53.     InitWindows();
  54.     InitMenus();
  55.     TEInit();
  56.     InitDialogs(0L);
  57.     InitCursor();
  58.     GetDateTime((unsigned long*)&randSeed);
  59.     
  60.     if (!InitTheEnvironment())            /* gestalt checks and variable initialization */
  61.         HandleError(kSystemTooOld, TRUE, FALSE);        /* less than system 4.1 */
  62.     
  63.     if (!programIntegrityVerified)    /* integrity check failed */
  64.         HandleError(kProgramIntegrityNotVerified, TRUE, FALSE);
  65.     
  66.     if (programIntegritySet)    /* integrity check freshly installed */
  67.         HandleError(kProgramIntegritySet, FALSE, FALSE);
  68.     
  69.     if (!InitTheGraphics())        /* initialize offscreen gworlds/bitmaps, etc */
  70.         HandleError(kNoMemoryAndQuitting, TRUE, FALSE);
  71.     
  72.     if (!InitTheMenus())        /* get menus from .rsrc and draw menu bar */
  73.         HandleError(kProgramIntegrityNotVerified, TRUE, FALSE);
  74.         
  75.     PrefsError(PreferencesInit());    /* get prefs (create if necessary) */
  76.     
  77.     InitTheProgram();                /* program-specific initialization */
  78.     
  79.     EventLoop();                    /* where it all happens (see below) */
  80.     
  81.     ShutDownEnvironment();            /* where it all ends (see below) */
  82.     
  83.     ExitToShell();
  84. }
  85.  
  86. void EventLoop(void)
  87. {
  88.     while (!gDone)    /* gDone set by choosing "Quit" menu item or by "quit" apple event */
  89.         HandleSingleEvent();
  90. }
  91.  
  92. Boolean HandleSingleEvent(void)
  93. {
  94.     EventRecord        theEvent;
  95.     short            i;
  96.     
  97.     SetCursor(&arrow);        /* should set once every time through event loop */
  98.     HiliteMenu(0);            /* normalize menubar */
  99.     
  100.     gFrontWindowIsOurs=FALSE;
  101.     gFrontWindowIndex=0;
  102.     if (FrontWindow()!=0L)    /* if there's a front window, see if it's one of ours */
  103.     {
  104.         for (i=0; ((i<NUM_WINDOWS) && (!gFrontWindowIsOurs)); i++)
  105.         {
  106.             if (FrontWindow()==GetIndWindowGrafPtr(i))    /* found one of ours, so SetPort */
  107.             {
  108.                 SetPort(GetIndWindowGrafPtr(i));
  109.                 gFrontWindowIsOurs=TRUE;
  110.                 gFrontWindowIndex=i;
  111.             }
  112.         }
  113.     }
  114.         
  115.     /* get an event from the queue */
  116.     GetTheEvent(&theEvent, gIsInBackground ? gBackgroundWaitTime : gForegroundWaitTime);
  117.     gCurrentEvent=theEvent;
  118.     
  119.     DispatchEvents(theEvent);    /* handle the event we just got */
  120.     
  121.     return (theEvent.what!=nullEvent);
  122. }
  123.  
  124. void GetTheEvent(EventRecord *theEvent, short waitTime)
  125. {
  126.     if (gWaitNextEventAvailable)
  127.         WaitNextEvent(everyEvent, theEvent, waitTime, 0L);
  128.     else
  129.     {
  130.         GetNextEvent(everyEvent, theEvent);
  131.         SystemTask();
  132.     }
  133. }
  134.  
  135. void GetCurrentEvent(EventRecord *currentEvent)
  136. {
  137.     *currentEvent=gCurrentEvent;
  138. }
  139.  
  140. void DispatchEvents(EventRecord theEvent)
  141. {
  142.     short            i;
  143.     Point            thisPoint;
  144.     short            index;
  145.     unsigned long    dummy;
  146.     WindowPtr        theWindow;
  147.     Boolean            thisWindowIsOurs;
  148.     
  149.     thisWindowIsOurs=FALSE;
  150.     /* for update/activate events, see if the window in question is one of ours */
  151.     if ((theEvent.what==activateEvt) || (theEvent.what==updateEvt))
  152.     {
  153.         for (i=0; ((i<NUM_WINDOWS) && (!thisWindowIsOurs)); i++)
  154.             thisWindowIsOurs=((WindowPtr)theEvent.message==GetIndWindowGrafPtr(i));
  155.     }
  156.  
  157.     if (thisWindowIsOurs)    /* for activate/update events, get window index */
  158.         index=(**((WindowDataHandle)GetWRefCon((WindowPtr)theEvent.message))).windowIndex;
  159.     else if (gFrontWindowIsOurs)    /* if front window is ours, get its window index */
  160.         index=gFrontWindowIndex;
  161.     else index=-1;
  162.     
  163.     switch (theEvent.what)
  164.     {
  165.         case nullEvent:    /* ain't nuthin' happenin' */
  166.             if (gFrontWindowIsOurs)        /* give control to window dispatch to handle null */
  167.                 CallIndDispatchProc(index, kNull, 0L);
  168.             break;
  169.         case mouseDown:    /* mouse button pressed */
  170.             HandleMouseDown(theEvent);    /* see below for mousedown handling */
  171.             break;
  172.         case keyDown:    /* key pressed */
  173.         case autoKey:    /* key help down */
  174.             if (theEvent.modifiers & cmdKey)    /* handle as command-key equivalent */
  175.             {
  176.                 AdjustMenus();    /* just to be safe */
  177.                 /* get the menu ID + item and handle it as a menu choice */
  178.                 HandleMenu(MenuKey((char)(theEvent.message & charCodeMask)));
  179.                 if ((gFrontWindowIsOurs) && (index==kMainWindow) &&
  180.                         (GetIndWindowGrafPtr(kMainWindow)!=0L))
  181.                     CallIndDispatchProc(index, kKeydown, theEvent.message);
  182.             }
  183.             else
  184.             {
  185.                 if (gFrontWindowIsOurs)    /* --> window's dispatch for keydown */
  186.                     CallIndDispatchProc(index, kKeydown, theEvent.message);
  187.             }
  188.             break;
  189.         case diskEvt:    /* disk insert */
  190.             if (HiWord(theEvent.message)!=noErr)    /* bad disk inserted */
  191.             {
  192.                 DILoad();    /* load disk initialization package */
  193.                 SetPt(&thisPoint, 120, 120);
  194.                 DIBadMount(thisPoint, theEvent.message);    /* give format? dialog */
  195.                 DIUnload();    /* unload 'cuz we certainly don't need it */
  196.             }
  197.             break;
  198.         case updateEvt:    /* window update */
  199.             theWindow=(WindowPtr)theEvent.message;    /* which window? */
  200.             
  201.             BeginUpdate(theWindow);        /* means: "OK, we're dealing with this now" */
  202.             
  203.             if (thisWindowIsOurs)        /* one of ours?  see graphics.c */
  204.                 UpdateTheWindow(GetIndWindowDataHandle(index));
  205.             /* if not, could be our progress bar */
  206.             else if ((theWindow!=0L) && (theWindow==gProgressDlog))
  207.                 UpdateDialog(theWindow, theWindow->visRgn);
  208.             
  209.             EndUpdate(theWindow);        /* means: "OK, we're done updating now" */
  210.             break;
  211.         case activateEvt:    /* window activate or deactivate */
  212.             if (thisWindowIsOurs)        /* one of ours?  send message to window dispatch */
  213.                 CallIndDispatchProc(index, ((theEvent.modifiers&activeFlag)!=0) ?
  214.                     kActivate : kDeactivate, 0L);
  215.             break;
  216.         case osEvt:            /* suspend or resume program execution (switch in/out) */
  217.             if (((theEvent.message>>24)&0x0FF)==suspendResumeMessage)
  218.             {
  219.                 /* keep track of whether we're in the background or foreground */
  220.                 gIsInBackground=((theEvent.message&resumeFlag)==0);
  221.                 
  222.                 if (gFrontWindowIsOurs)        /* send activate/deactivate to front window */
  223.                     CallIndDispatchProc(index, gIsInBackground ? kDeactivate : kActivate, 0L);
  224.                 
  225.                 for (i=0; i<NUM_WINDOWS; i++)    /* send suspend/resume to all our */
  226.                     if (GetIndWindowGrafPtr(i)!=0L)        /* windows that currently exist */
  227.                         CallIndDispatchProc(i, gIsInBackground ? kSuspend : kResume, 0L);
  228.                 
  229.                 /* if we just came into the foreground and we have a pending error,
  230.                    now's the time to display it */
  231.                 if ((!gIsInBackground) && (gPendingResultCode!=allsWell))
  232.                 {
  233.                     if (gHasNotificationManager)
  234.                         NMRemove(&gMyNotification);        /* remove notification request */
  235.                     HandleError(gPendingResultCode, gPendingETS, gUsePendingParams);    /* display alert, see error.c */
  236.                     gPendingResultCode=allsWell;        /* ...now it is */
  237.                 }
  238.             }
  239.             break;
  240.         case kHighLevelEvent:    /* apple event */
  241.             if (gHasAppleEvents)
  242.                 AEProcessAppleEvent(&theEvent);        /* see apple events.c */
  243.             break;
  244.     }
  245. }
  246.  
  247. void HandleMouseDown(EventRecord theEvent)
  248. {
  249.     WindowPtr            theWindow;
  250.     short                windowCode;
  251.     long                windSize;
  252.     GrafPtr                oldPort;
  253.     short                i;
  254.     Rect                sizeRect;
  255.     Boolean                gotone;
  256.     short                index;
  257.     unsigned long        dummy;
  258.     Point                theLocalPoint;
  259.     Boolean                thisWindowIsOurs;
  260.     ExtendedWindowDataHandle    theData;
  261.     
  262.     windowCode=FindWindow(theEvent.where, &theWindow);    /* which window? */
  263.  
  264.     thisWindowIsOurs=FALSE;
  265.     /* find out if the target window was one of ours */
  266.     if (theWindow!=0L)
  267.         for (index=0; ((index<NUM_WINDOWS) && (!thisWindowIsOurs)); index++)
  268.             thisWindowIsOurs=(theWindow==GetIndWindowGrafPtr(index));
  269.  
  270.     if (thisWindowIsOurs)    /* if target window is one of ours, get window data struct */
  271.     {
  272.         theData=(ExtendedWindowDataHandle)GetWRefCon(theWindow);
  273.         index=(**theData).windowIndex;
  274.     }
  275.     else index=-1;
  276.     
  277.     switch (windowCode)
  278.     {
  279.         case inMenuBar:        /* in menu bar; let system take over */
  280.             AdjustMenus();
  281.             HandleMenu(MenuSelect(theEvent.where));
  282.             break;
  283.         case inContent:        /* in window content */
  284.             if (FrontWindow() != theWindow)        /* maybe switch to different window */
  285.             {
  286.                 if (FrontWindow()==gProgressDlog)    /* but not if progress bar is up */
  287.                     SysBeep(7);
  288.                 else SelectWindow(theWindow);
  289.             }
  290.             else if (gFrontWindowIsOurs)    /* inform window dispatch of mousedown */
  291.             {
  292.                 theLocalPoint=theEvent.where;
  293.                 GlobalToLocal(&theLocalPoint);
  294.                 dummy=theLocalPoint.h;        /* all this fiddling is so we can pass */
  295.                 dummy=dummy<<16;            /* the point (two integers) to the */
  296.                 dummy+=theLocalPoint.v;        /* dispatch procedure in an unsigned long */
  297.                 CallIndDispatchProc(index, kMousedown, dummy);    /* go for it */
  298.             }
  299.             break;
  300.         case inSysWindow:    /* in system window (desk accessory) */
  301.             SystemClick(&theEvent, theWindow);    /* let the system deal with it */
  302.             break;
  303.         case inDrag:        /* in drag _region_, that is */
  304.             /* the accepted way to draw a window */
  305.             DragWindow(theWindow, theEvent.where, &((**GetGrayRgn()).rgnBBox));
  306.             if (thisWindowIsOurs)    /* update window bounds in window data struct */
  307.                 (**theData).windowBounds=
  308.                     (*(((WindowPeek)GetIndWindowGrafPtr(index))->contRgn))->rgnBBox;
  309.             break;
  310.         case inGoAway:        /* close box */
  311.             /* the accepted way to track a close box attempt */
  312.             if (TrackGoAway(theWindow, theEvent.where))
  313.                 DoTheCloseThing((WindowPeek)theWindow);        /* see menus.c */
  314.             break;
  315.         case inGrow:        /* grow box */
  316.             /* the accepted way to grow a window */
  317.             sizeRect = screenBits.bounds;
  318.             OffsetRect(&sizeRect, sizeRect.left, sizeRect.top);
  319.             
  320.             windSize = GrowWindow(theWindow, theEvent.where, &sizeRect);
  321.             if (windSize != 0)
  322.             {
  323.                 GetPort(&oldPort);
  324.                 SetPort(theWindow);
  325.                 EraseRect(&theWindow->portRect);
  326.                 SizeWindow(theWindow, LoWord(windSize), HiWord(windSize), TRUE);
  327.                 InvalRect(&theWindow->portRect);
  328.                 SetPort(oldPort);
  329.             }
  330.             
  331.             if (thisWindowIsOurs)    /* update window bounds in window data struct */
  332.                 (**theData).windowBounds=
  333.                     (*(((WindowPeek)GetIndWindowGrafPtr(index))->contRgn))->rgnBBox;
  334.             break;
  335.         case inZoomIn:        /* zoom box */
  336.         case inZoomOut:
  337.             /* the accepted way to track a zoom attempt */
  338.             if (TrackBox(theWindow, theEvent.where, windowCode))
  339.             {
  340.                 GetPort(&oldPort);
  341.                 SetPort(theWindow);
  342.                 ZoomWindow(theWindow, windowCode, FALSE);
  343.                 InvalRect(&theWindow->portRect);
  344.                 SetPort(oldPort);
  345.             }
  346.             
  347.             if (thisWindowIsOurs)    /* update window bounds in window data struct */
  348.                 (**theData).windowBounds=
  349.                     (*(((WindowPeek)GetIndWindowGrafPtr(index))->contRgn))->rgnBBox;
  350.             break;
  351.     }
  352. }
  353.  
  354. void ShutDownEnvironment(void)
  355. {
  356.     SaveThePrefs();
  357.     ShutDownTheProgram();        /* program-specific cleanup */
  358.     ShutDownTheGraphics();        /* shell-specific clean-up */
  359. }
  360.